package P1.erfen;

import java.util.Scanner;

/**
 * @date:2022/10/12
 * @author:CqLtd
 * @name:idealist
 */
/*
二分问题的解题流程是：先写check函数，之后想好该如何基于check的结果更新区间的左右端点（也就是想好是采用第一个模板还是第二个模板），之后使用对应的模板

或者说，如果更新区间的操作中有r = mid，那么mid的值就是l+r>>1；如果更新区间的操作中有l = mid，那么mid就是l+r+1>>1
 */
public class BinarySearch {
    public static void main(String[] args) {
        Scanner scanner=new Scanner(System.in);
      //  System.out.println("请输入数组大小");
        int n=scanner.nextInt();
        //  System.out.println("请输入要搜索的次数");
        int z=scanner.nextInt();
        int[] q=new int[n];
      //  System.out.println("请输入数组");
        for(int i=0;i< n;i++){
            q[i]=scanner.nextInt();
        }

        for (int i = 0; i < z; i++) {
            int m= scanner.nextInt();
            int l=0,r=n-1;
            while(l<r){
                int mid=l+r>>1;
                if(q[mid]>=m) r=mid;
                else l=mid+1;
            } //区间右半边的边界点
            if(q[l]!=m) System.out.println("-1 -1");
            else{
                System.out.print(l+" ");
               l=0;r=n-1;
               while(l<r){
                   int mid=l+r+1>>1;
                   if(q[mid]<=m) l=mid;
                   else r=mid-1;
               }//区间左半边的边界点
                System.out.println(l);
            }

        }



//        if(res==0){
//            System.out.println("没找到");
//        }
//        else System.out.println("位置为"+res);

    }
    //二分法（递归实现）[left, right] 左闭右闭
    private static int BinarySearch01(int arr [],int l,int r,int x){
        if(r>=l){
            int middle=l+(r-l)/2;
            if (arr[middle]==x)
                return middle;
            if(arr[middle]>x)
                return BinarySearch01(arr, l, middle - 1, x);
            return BinarySearch01(arr,middle+1,r,x);
        }
        return -1;
    }
    //二分法（递归实现）在左闭右开的区间里，也就是[left, right)
    private static int BinarySearch02(int arr [],int l,int r,int x){
        if(r>l){
            int middle=l+(r-l)/2;
            if (arr[middle]==x)
                return middle;
            if(arr[middle]>x)
                return BinarySearch02(arr, l, middle , x);
            return BinarySearch02(arr,middle+1,r,x);
        }
        return -1;
    }
    // target 是在一个在左闭右闭的区间里，也就是[left, right] ,非递归实现
    private static int BinarySearch03(int arr [],int l,int r,int x){
        while(r>=l){
            int middle=l+(r-l)/2;
            if(arr[middle]==x) return middle;
            else if(arr[middle]>x) r=middle-1;
            else l=middle+1;
        }

        return -1;
    }
    // target 是在一个在左闭右开的区间里，也就是[left, right) ,非递归实现
    private static int BinarySearch04(int arr [],int l,int r,int x){
        while(r>l){
            int middle=l+(r-l)/2;
            if(arr[middle]>x) r=middle;
            else if(arr[middle]<x) l=middle+1;
            else return middle;
        }
        return -1;
    }
//区间[l,r]被划分为[l,mid-1]和[mid,r]时
    private static int BinarySearch05(int arr [],int l,int r,int x){
        while(r>l){
            int middle=l+(r-l)+1>>1;
            if(arr[middle]>x) r=middle;
            else if(arr[middle]<x) l=middle+1;
            else return middle;
        }
        return -1;
    }
}
